const { sqlCheckType, err_reply, success_reply, registerResultType } = require("../types/type.js"); // 引入枚举类型、响应

var dbConfig = require("../../util/dbconfig.js"); // 引入dbconfig

var timeExchange = require("../.././tools/timeExchange.js"); // 封装好的时间工具

const crypto = require("crypto"); //生成token用的

const { validateLoginState } = require("../base/base_validate.js"); // 登录校验

// 引入数据格式化函数
const { format_menuListData } = require("../menu/jss_math.js");

// 验证手机号，是否已经注册
function validateRegisterPhone(phone, res, req, mineCallBack) {
  console.log("要查询的手机号是 -> : " + phone);
  var sql_check = "SELECT id from`login` WHERE phone=?";
  var sqlParamters = [phone]; //参数，替换sql里面的占位符？

  var callBack = (err, data) => {
    if (err) {
      console.log("validateRegisterPhone -> err is: " + err);
      const msg = `查询数据异常，请联系管理员并提供手机号：${req.body.phone}`;
      err_reply("validateRegisterPhone", res, msg);
      mineCallBack(sqlCheckType.Error);
    } else {
      console.log("手机号数据，查询成功");
      // console.log(JSON.stringify(data))
      if (data === null || data.length == 0) {
        console.log("手机号不存在，可以注册!");
        mineCallBack(sqlCheckType.False);
      } else {
        console.log("手机号已经注册过!");
        mineCallBack(sqlCheckType.True);
      }
    }
  };
  dbConfig.sqlConnect(sql_check, sqlParamters, callBack);
}

// 验证该账号(account)，是否已经登录
function validateLoginAccount(account, res, req, mineCallBack) {
  var sql_select = "SELECT id from`login` WHERE account=?";
  var sqlParamters = [account]; //参数，替换sql里面的占位符？

  var callBack = (err, data) => {
    
    if (err) {
      console.log("账号数据，查询出错了 err is: " + err);
      const msg = `查询数据异常，请联系管理员，并提供该账号：${account}`
      err_reply('validateLoginAccount',res, msg)
      mineCallBack(sqlCheckType.Error);
    } else {
      // console.log("validateLoginAccount -> data: " + JSON.stringify(data));
      if (data === null || data.length == 0) {
        console.log("该账号不存在，不能登录!");
        mineCallBack(sqlCheckType.False);
      } else {
        // console.log('该账号已经注册过!')
        mineCallBack(sqlCheckType.True);
      }
    }
  };
  dbConfig.sqlConnect(sql_select, sqlParamters, callBack);
}

/**
 *  @description 获取验证码
 * */
const get_verifycode = function (req, res, next) {
  // req.query、req.params、req.body
  console.log("\n获取验证码请求～");
  console.log("3参数phone是：" + JSON.stringify(req.query));
  console.log("3-1参数phone是：" + req.query.phone);

  const phone = req.query.phone; // 手机号

  const type = req.query.type; // 验证码类型：  1：注册，2：登录，3：修改密码；

  // validateRegisterPhone - 回调函数
  var phoneValidateCallback = (result) => {
    if (result == sqlCheckType.Error) {
      return;
    } else if (result == sqlCheckType.True) {
      // 能查到该手机号，可以登录、可以修改密码、不能注册
      if (type === "1") {
        console.log("注册 - 验证码");
        err_reply("/verifyCode", res, `${phone}，该手机号已经注册`);
      } else if (type === "2") {
        console.log("登录 - 验证码");
        verifyCode_next(req, res, 2);
      } else if (type === "3") {
        console.log("修改密码 - 验证码");
        verifyCode_next(req, res, 3);
      }
    } else if (result == sqlCheckType.False) {
      // 没查到该手机数据，不可以登录、不可以修改密码、可以注册
      if (type === "1") {
        console.log("注册 - 验证码");
        verifyCode_next(req, res, 1);
      } else if (type === "2") {
        console.log("登录 - 验证码");
        err_reply("/verifyCode", res, `${req.query.phone}，该手机号尚未注册`);
      } else if (type === "3") {
        console.log("修改密码 - 验证码");
        err_reply("/verifyCode", res, `${req.query.phone}，该手机号尚未注册`);
      }
    }
  };

  // 校验手机号码是否已经注册过，未注册则返回true
  validateRegisterPhone(req.query.phone, res, req, phoneValidateCallback);
};
// 从router.get('/verifyCode'）抽出来的代码
function verifyCode_next(req, res, type) {
  /**
   * 这个‘verifyCode_next函数’的代码不完整，没有对验证码的类型进行区分（注册、手机登录、修改密码）
   * @memberof 暂时先混合着用吧，真的没时间兼顾-前、后端代码，后面有空再完善
   */

  // type: 1 - 注册；2 - 手机号登录；3 - 修改密码
  var paddedNumber = ""; // 存放验证码
  if (req.session.captcha && req.session.captcha.phone) {
    console.log("session有数据，直接拿出来");
    console.log(req.session.captcha);
    console.log(req.session.captcha.phone);
    paddedNumber = req.session.captcha.phone;
  } else {
    console.log("session没有数据，需要创建");
    // 生成一个0到9999之间的随机数
    const randomNumber = Math.floor(Math.random() * 10000);
    // 将数字转换为字符串，并在前面补零，以确保总是四位数
    paddedNumber = String(randomNumber).padStart(4, "0");
    console.log("4位数的随机验证码是：" + paddedNumber);
    // console.log('phone是：' + req.query.phone)

    // 1、存储到redis服务器上(此方法无效)
    // redisTools.storeSmsCode(req.query.phone, paddedNumber);

    // 2、存储到session（有效）
    req.session.captcha = {
      phone: paddedNumber,
      expire: Date.now() + 60000, // 设置验证码的过期时间
    };
  }

  success_reply(
    "/verifyCode",
    res,
    "验证码已发送(5分钟内有效)，" + paddedNumber,
    {}
  );
}

/**
 *  @description 注册
 * */
const post_register = (req, res) => {
  console.log(
    "\n\n接收到注册请求（register），从body取出参数：" +
      JSON.stringify(req.body)
  ); //req.query.userID
  p_register(req, res, true, true, null)
  
};
/**
 * 注册请求（用户注册、管理添加用户，都会用到）
 * @param {*} req 
 * @param {*} res 
 * @param {*} needValidateCode 是否需要 校验手机验证码 （默认需）
 * @param {*} isNeedSendClient 是否需要 相应客户端    （默认需）
 * @param {*} callBack 回调函数，将结果告知此方法的调用者, 返回三个参数(result:boolean, code:registerResultType, insertId: number)
 * @returns Promise , 三个参数(result:boolean, code:registerResultType, insertId: number)
 */
function p_register(req, res, needValidateCode = true, isNeedSendClient = true, callBack = null) {
  return new Promise((reslove) => {
    // 校验手机号码是否已经注册过，返回sqlCheckType类型
    var accountValidateCallback = (result) => {
      if (result == sqlCheckType.Error) {
        reslove([false, registerResultType.FALSE, null])
        return;
      } else if (result == sqlCheckType.True) {
        console.log("注册失败，该账号已经被注册！");
        if (isNeedSendClient) {
          err_reply('p_register', res, `${req.body.name}，已经注册过`)
        }
        if(callBack) callBack(false, registerResultType.ALREADY_EXISTS)

        reslove([false, registerResultType.ALREADY_EXISTS, null])
        return;
      } else if (result == sqlCheckType.False) {
        // 没查到该手机数据，可以注册
      }
      console.log("继续注册逻辑");

      // 拿出验证码
      if (needValidateCode) {
        const code = req.session.captcha ? req.session.captcha.phone : "";
        console.log("code:" + JSON.stringify(code));
        console.log("req.body.verifyCode:" + req.body.verifyCode);
        if (code == "") {
          if (isNeedSendClient) {
            err_reply('p_register', res, '验证码已过期，请重新获取')
          }
          if(callBack) callBack(false, registerResultType.OVERDUE)

          reslove([false, registerResultType.OVERDUE, null])
          return;
        }
        if (req.body.verifyCode != code) {
          if (isNeedSendClient) {
            err_reply('p_register', res, '验证码不匹配，请重新输入')
          }
          if(callBack) callBack(false, registerResultType.MISMATCH)
          
          reslove([false, registerResultType.MISMATCH, null])
          return;
        }
        console.log("验证码输入正确");
      }

      var times = timeExchange.timeString_3daysLater(); // 拿到:当前时间、3天后的时间
      console.log(`当前时间是: ${times.current}   三天后时间:${times.expire}`);
      var loginTime = times.current; // 获取当前时间，格式：2024-03-30 03:41:48
      var expireTime = times.expire; // 获取token过期时间，格式：2024-04-02 03:41:48
      // 注册成功，就相当于手机登录
      // type: 登录方式: 1 - 账号登录； 2 - 手机登录
      var sql_insert =
        "INSERT INTO `login`(account,password,phone,login_type,token,expire_time,login_time) VALUES (?, ?, ?, ?, ?, ?, ?)";

      const tokenValue = crypto.randomBytes(20).toString("hex"); // 一个随机生成的token

      var sqlParamters = [
        req.body.account,
        req.body.password,
        req.body.phone,
        "2",
        tokenValue,
        expireTime,
        loginTime,
      ]; //参数，替换sql里面的占位符？
      console.log('sqlParamters:  ' + JSON.stringify(sqlParamters))
      var insert_callBack = (err, data) => {
        if (err) {
          console.log("post请求出错了");
          console.log("err: " + err);
          if (isNeedSendClient) {
            err_reply('p_register', res, '注册请求出错了')
          }
          if(callBack) callBack(false, registerResultType.FALSE)

          reslove([false, registerResultType.FALSE, null])
          return;
        } else {
          console.log("\n-》注册 - post请求成功！！！\n");
          console.log("打印data: " + JSON.stringify(data))
          if(data.affectedRows <= 0) {
            if(callBack) callBack(false, registerResultType.FALSE)
            reslove([false, registerResultType.FALSE, null])
          } else {
            if(callBack) callBack(false, registerResultType.TRUE, data.insertId)
            // data格式~~ {"fieldCount":0,"affectedRows":1,"insertId":10056,"serverStatus":2,"warningCount":0,"message":"","protocol41":true,"changedRows":0}
            if (isNeedSendClient) {
              const msg = `恭喜账号${req.body.name}，注册成功`
              dataObj = {
                user_id: data.insertId,
                token: tokenValue,
              }
              // res.send 一定要放在最后执行，否则会报错：Cannot set headers after they are sent to the client
              success_reply('p_register', res, msg, dataObj)
            }
            reslove([true, registerResultType.TRUE, data.insertId])
          }
        }
      };
      // 发送请求
      dbConfig.sqlConnect(sql_insert, sqlParamters, insert_callBack);
    };
    
    // console.log("aaaaaaaa -> account: " + req.body.name);
    // 校验手机号码是否已经注册过
    validateLoginAccount(req.body.name, res, req, accountValidateCallback);
  })
}

/**
 *  @description 账号登录
 * */
const post_login_account = (req, res) => {
  console.log(
    "\n\n接收到登录请求（loginAccount，从body取出参数：）" +
      JSON.stringify(req.body)
  ); //req.query.userID

  var accountValidateCallback = (result) => {
    if (result == sqlCheckType.Error) {
      return;
    } else if (result == sqlCheckType.True) {
      // 能查到该手机号，可以登录
    } else if (result == sqlCheckType.False) {
      // 没查到该手机数据，不可以登录
      err_reply('post_login_account', res, `${req.body.account}，该账号尚未注册`)
      return;
    }
    // console.log('继续登录逻辑')

    // var timeExchange = require('../tools/timeExchange.js'); // 封装好的时间工具
    var times = timeExchange.timeString_3daysLater(); // 拿到:当前时间、3天后的时间
    console.log(`当前时间是: ${times.current}   三天后时间:${times.expire}`);
    var loginTime = times.current; // 获取当前时间，格式：2024-03-30 03:41:48
    var expireTime = times.expire; // 获取token过期时间，格式：2024-04-02 03:41:48

    // type: 登录方式: 1 - 账号登录； 2 - 手机登录
    var sql_check = "SELECT * FROM `login` where account=?";
    const tokenValue = crypto.randomBytes(20).toString("hex"); // 一个随机生成的token
    // console.log('随机生成token：'+token); // 输出一个随机生成的token
    var sqlParamters = [req.body.account]; //参数，替换sql里面的占位符？

    var callBack = (err, data) => {
      if (err) {
        console.log("登录请求出错了");
        console.log("err: " + err);
        return;
      } else {
        // console.log("data: " + JSON.stringify(data))
        if (data === null || data.length == 0) {
          console.log("数据查询失败，空数据！！");
        } else {
          // console.log("data is :" + JSON.stringify(data));
          if (data.length > 1) {
            console.log(`数据异常警告：账号${req.body.account}存在多条数据`);
            err_reply('post_login_account', res, `${req.body.account}登录失败，数据异常`)
            return;
          }
          console.log(
            `req.body.pwd:${req.body.pwd}  data[0].password:${data[0].password}}`
          );
          // 判断密码是否正确
          if (req.body.pwd != data[0].password) {
            err_reply('post_login_account', res, `${req.body.account}登录失败，密码不正确`)
            return;
          }
          console.log("\n登录请求成功！！！\n");

          //更新token及token过期时间
          // var timeExchange = require('../tools/timeExchange.js'); // 封装好的时间工具
          var times = timeExchange.timeString_3daysLater(); // 拿到:当前时间、3天后的时间
          console.log(
            `当前时间是: ${times.current}   三天后时间:${times.expire}`
          );
          var loginTime = times.current; // 获取当前时间，格式：2024-03-30 03:41:48
          var expireTime = times.expire; // 获取token过期时间，格式：2024-04-02 03:41:48

          // type: 登录方式: 1 - 账号登录； 2 - 手机登录
          var sql_update =
            "UPDATE `login` set login_type=?,token=?, expire_time=?, login_time=? where account=? && password=?";
          // const tokenValue = crypto.randomBytes(20).toString('hex'); // 一个随机生成的token
          // console.log('随机生成token：'+token); // 输出一个随机生成的token
          var sqlParamters = [
            "1",
            tokenValue,
            expireTime,
            loginTime,
            req.body.account,
            req.body.pwd,
          ]; //参数，替换sql里面的占位符？
          dbConfig.sqlConnect(
            sql_update,
            sqlParamters,
            (update_err, updateData) => {
              // console.log("更新token、登录时间");
              if (update_err) {
                console.log("更新token请求，出错了");
                err_reply('post_login_account', res, `${req.body.account}，登录异常`)
                return;
              } else {
                console.log(
                  "更新token请求，成功了：" + JSON.stringify(updateData)
                );
                if (data.length > 1) {
                  console.log(
                    `数据异常警告：账号${req.body.account}存在多条数据`
                  );
                  err_reply('post_login_account', res, `${req.body.account}登录失败，数据异常`)
                  return;
                }
                // 查询结果只有一条，可以用
                // 由于data是更新之前的查询数据，所以要把最新的token、expire_time、ogin_time更改掉
                // console.log("原先请求返回的是: " + data);
                data[0].token = tokenValue;
                data[0].loginTime = loginTime;
                data[0].expireTime = expireTime;
                // console.log("更改后请求返回的是: " + data);
                const msg = `恭喜账号${req.body.account}，登录成功`
                success_reply('accountValidateCallback', res, msg, data[0])
                return;
              }
            }
          );
        }
      }
    };
    dbConfig.sqlConnect(sql_check, sqlParamters, callBack);
  };

  // 校验手机号码是否已经注册过，未注册则返回true
  validateLoginAccount(req.body.account, res, req, accountValidateCallback);
};

/**
 *  @description 手机号登录
 * */
const post_login_phone = (req, res) => {
  console.log(
    "\n\n接收到手机登录请求（loginPhone），从body取出参数：" +
      JSON.stringify(req.body)
  );

  // 校验手机号码是否已经注册过，返回sqlCheckType类型
  var phoneValidateCallback = (result) => {
    if (result == sqlCheckType.Error) {
      return;
    } else if (result == sqlCheckType.True) {
      // 能查到该手机号，可以登录
    } else if (result == sqlCheckType.False) {
      // // 没查到该手机数据，不可以登录
      err_reply('post_login_phone', res, `${req.body.name}，该手机号尚未注册`)
    }
    console.log("继续手机登录逻辑");

    // 拿出验证码
    const code = req.session.captcha ? req.session.captcha.phone : "";
    console.log("code:" + JSON.stringify(code));
    console.log("req.body.verifyCode:" + req.body.verifyCode);
    if (code == "") {
      err_reply('post_login_phone', res, "验证码已过期，请重新获取")
      return;
    }
    if (req.body.verifyCode != code) {
      err_reply('post_login_phone', res, "验证码不匹配，请重新输入")
      return;
    }
    console.log("验证码输入正确");

    const phone = req.body.phone; //拿出请求参数：手机号

    // var timeExchange = require('../tools/timeExchange.js'); // 封装好的时间工具
    var times = timeExchange.timeString_3daysLater(); // 拿到：当前时间、3天后的时间
    console.log(`当前时间是: ${times.current}   三天后时间:${times.expire}`);
    var loginTime = times.current; // 获取当前时间，格式：2024-03-30 03:41:48
    var expireTime = times.expire; // 获取token过期时间，格式：2024-04-02 03:41:48

    // type: 登录方式: 1 - 账号登录； 2 - 手机登录
    var sql_update =
      "UPDATE `login` set login_type=?,token=?, expire_time=?, login_time=? where phone=?";
    const tokenValue = crypto.randomBytes(20).toString("hex"); // 一个随机生成的token
    var sqlParamters = ["2", tokenValue, expireTime, loginTime, phone]; //参数，替换sql里面的占位符？
    // 定义 - 回调函数
    var callBack = (update_err, update_data) => {
      console.log("update_err: " + update_err);
      console.log(
        "手机登录-login表-更新结果data: " + JSON.stringify(update_data)
      );
      if (update_err) {
        console.log("手机登录-login表 - 更新请求出错了");
        err_reply('post_login_phone', res, `${req.body.phone}，手机登录 - 更新请求出错了`)
        return;
      } else {
        console.log("手机登录-login表 - 更新请求成功");
        // 接下来查询表数据
        var sql_check = "SELECT * FROM `login` where phone=?";
        var sqlParamters = [req.body.phone]; //参数，替换sql里面的占位符？
        // 发送 - 查询请求
        dbConfig.sqlConnect(sql_check, sqlParamters, (check_err, checkData) => {
          console.log("手机登录-login表-查询-所有数据:" + checkData);
          if (check_err) {
            console.log("手机登录-login表-查询，出错了");
            err_reply('post_login_phone', res, `${req.body.phone}，查询登录表-异常`)
            return;
          } else {
            console.log(
              "手机登录-login表-查询，成功了：" + JSON.stringify(checkData)
            );
            if (checkData.length > 1) {
              console.log(`数据异常警告：账号${req.body.phone}存在多条数据`);
              err_reply('post_login_phone', res, `${req.body.phone}登录失败，数据异常`)
              return;
            }
            success_reply('post_login_phone', res, `恭喜手机号${req.body.phone}，登录成功`, checkData[0])
            return;
          }
        });
      }
    };
    // 发送更新请求
    dbConfig.sqlConnect(sql_update, sqlParamters, callBack);
  };

  // 校验手机号码是否已经注册过，返回sqlCheckType类型
  validateRegisterPhone(req.body.phone, res, req, phoneValidateCallback);
};

/**
 *  @description 获取用户详情
 * */
const get_userinfo = function (req, res, next) {
  console.log('正在获取用户详情')
  console.log(
    "\n\n接收到获取用户详情请求（userInfo），参数user_id是：" +
      req.query.user_id
  );
  const user_id = req.query.user_id;
  if (!user_id || user_id.length == 0) {
    err_reply('get_userinfo', res, "请求失败，用户ID不能为空")
    return;
  } else {
    // var sql_check = "SELECT * from`userInfo` WHERE user_id=?"
    // 连表查询
    var sql_check =
      `SELECT t1.*, t2.role_name FROM userInfo t1 LEFT JOIN role t2 on t1.role_id = t2.role_level WHERE user_id=${user_id}`;
    var sqlParamters = []; //参数，替换sql里面的占位符？

    var callBack = (err, data) => {
      if (err) {
        console.log("该user_id数据，查询出错了 err is: " + err);
        err_reply('get_userinfo', res, `查询数据异常，请联系管理员，并提供用户ID：${user_id}`)
      } else {
        console.log("手机号数据，查询成功");
        console.log("userInfo -> 请求返回(data): " + JSON.stringify(data));
        if (data === null || data.length == 0) {
          console.log("该user_id数据不存在!");
          console.log(sql_check)
          err_reply('get_userinfo', res, `该user_id数据不存在，请联系管理员，并提供用户ID：${user_id}`)
        } else {
          console.log("数据查询成功!");
          if (data.length > 1) {
            console.log(`数据异常警告：该ID${user_id}存在多条数据`);
            err_reply('get_userinfo', res, `${user_id}请求失败，数据异常`)
            return;
          }
          setTimeout(() => {
            success_reply('get_userinfo', res, "查询成功",data[0])
          }, 100);
        }
      }
    };
    dbConfig.sqlConnect(sql_check, sqlParamters, callBack);
  }
};

/**
 *  @description 获取菜单列表
 * */
const get_menulist = async function (req, res, next) {
  // 1、校验登录状态
  const validateLogin = await validateLoginState(
    res,
    req,
    "get",
    "get_menulist"
  );
  if (!validateLogin) return;

  const user_id = req.query.user_id ?? "";

  /** 
   * SELECT tb1.* FROM
    (SELECT id, tag ,CONCAT('、', permissions_role_ids, '、') AS permissions_role_ids_deal
    FROM menu) AS tb1
    WHERE permissions_role_ids_deal LIKE '%、12、%'; 
*/
  // SQL语句
  const sql_check = `SELECT tb1.* FROM
  (SELECT * ,CONCAT('、', permissions_role_ids, '、') AS permissions_role_ids_deal
  FROM ${`menu`}) AS tb1
  
  WHERE permissions_role_ids_deal LIKE 
  (SELECT CONCAT('%、', role_id, '、%' ) as  role_id_new FROM ${`userInfo`} WHERE user_id='${user_id}');`;

  // SQL语句参数
  const sql_params = [];

  // 开始请求
  dbConfig.sqlConnect(sql_check, sql_params, (err, data) => {
    if (err) {
      console.log("get_menulist 查询出错啦！！");
      console.log(err);
      err_reply("menu/list", res, "菜单列表查询出错啦！");
    } else {
      console.log("get_menulist 查询成功！！111");
      // console.log('\n\nsql---' + sql_check)
      // console.log('\n\n')

      // 格式化一下
      let formateData = format_menuListData([], data, "menu_type");
      // console.log("按照menu_type格式化111！！", formateData);
      // 对menu_type重新设置
      // 虽然顺序对了，但是menu_type的序号默认还是按照管理员的权限排序的
      for (let index = 0; index < formateData.length; index++) {
        const element = formateData[index];
        element['menu_type'] = index + 1 // 从1开始
      }
      
      // console.log("按照menu_type格式化222！！", formateData);

      success_reply("menu/list", res, "111菜单列表查询成功！", formateData);
    }
  });

  // return

  // type=1表示没有子菜单，即children数组为空
  // const data = {
  //   title: '菜单列表',
  //   list: [
  //     {
  //       index: '1',
  //       parent_id: '0',
  //       iconName: 'icon-menu-intruduce.png',
  //       title: '项目介绍',
  //       sort: '107',
  //       type: 1,
  //       url: '/layoutView/introduceProjectView',
  //       children: [],
  //     },
  //     {
  //       index: '2',
  //       parent_id: '0',
  //       iconName: 'icon-menu-produce.png',
  //       title: '产品中心',
  //       sort: '109',
  //       type: 2,
  //       page: '',
  //       children: [
  //         {
  //           index: '2-1',
  //           parent_id: '2',
  //           iconName: 'icon-home.png',
  //           title: '产品分类',
  //           sort: '110',
  //           type: 1,
  //           url: '/product-center/product-category',
  //           children: [],
  //         },
  //         {
  //           index: '2-2',
  //           parent_id: '2',
  //           iconName: 'icon-home.png',
  //           title: '产品信息',
  //           sort: '111',
  //           type: 1,
  //           url: '/product-center/product-information',
  //           children: [],
  //         },
  //       ],
  //     },
  //     {
  //       index: '3',
  //       parent_id: '0',
  //       iconName: 'icon-menu-manage.png',
  //       title: '系统管理',
  //       sort: '112',
  //       type: 2,
  //       page: '',
  //       children: [
  //         {
  //           index: '3-1',
  //           parent_id: '3',
  //           iconName: 'icon-home.png',
  //           title: '部门管理',
  //           sort: '113',
  //           type: 1,
  //           url: '/sys-management/department-management',
  //           children: [],
  //         },
  //         {
  //           index: '3-2',
  //           parent_id: '3',
  //           iconName: 'icon-home.png',
  //           title: '菜单管理',
  //           sort: '114',
  //           type: 1,
  //           url: '/sys-management/menu-management',
  //           children: [],
  //         },
  //         {
  //           index: '3-3',
  //           parent_id: '3',
  //           iconName: 'icon-home.png',
  //           title: '角色管理',
  //           sort: '115',
  //           type: 1,
  //           url: '/sys-management/role-management',
  //           children: [],
  //         },
  //         {
  //           index: '3-4',
  //           parent_id: '3',
  //           iconName: 'icon-home.png',
  //           title: '用户管理',
  //           sort: '116',
  //           type: 1,
  //           url: '/sys-management/user-management',
  //           children: [],
  //         },
  //       ],
  //     },
  //     {
  //       index: '4',
  //       parent_id: '0',
  //       iconName: 'icon-menu-overview.png',
  //       title: '系统总览',
  //       sort: '120',
  //       type: 2,
  //       page: '',
  //       children: [
  //         {
  //           index: '4-1',
  //           parent_id: '4',
  //           iconName: 'icon-home.png',
  //           title: '商品统计',
  //           sort: '121',
  //           type: 1,
  //           url: '/sys-overview/product-statistics-view',
  //           children: [],
  //         },
  //         {
  //           index: '4-2',
  //           parent_id: '4',
  //           iconName: 'icon-home.png',
  //           title: '核心技术',
  //           sort: '122',
  //           type: 1,
  //           url: '/sys-overview/technology-view',
  //           children: [],
  //         },
  //       ],
  //     },
  //     {
  //       index: '5',
  //       parent_id: '0',
  //       iconName: 'icon-menu-stroke.png',
  //       title: '日常流程',
  //       sort: '130',
  //       type: 2,
  //       page: '',
  //       children: [
  //         {
  //           index: '5-1',
  //           parent_id: '5',
  //           iconName: 'icon-home.png',
  //           title: '任务列表',
  //           sort: '131',
  //           type: 1,
  //           url: '/other/task-list',
  //           children: [],
  //         },
  //         {
  //           index: '5-2',
  //           parent_id: '5',
  //           iconName: 'icon-home.png',
  //           title: '我的日记',
  //           sort: '132',
  //           type: 2,
  //           url: '/other/my-diary',
  //           children: [
  //             {
  //               index: '5-2-1',
  //               parent_id: '5-2',
  //               iconName: 'icon-home.png',
  //               title: '日记列表',
  //               sort: '133',
  //               type: 1,
  //               url: '/other/diary-list',
  //               children: [],
  //             },
  //             {
  //               index: '5-2-2',
  //               parent_id: '5-2',
  //               iconName: 'icon-home.png',
  //               title: '新增日记',
  //               sort: '134',
  //               type: 1,
  //               url: '/other/diary-add',
  //               children: [],
  //             },
  //           ],
  //         },
  //       ],
  //     },
  //   ],
  // }

  // const data = {
  //   title: '菜单列表',
  //   list: [
  //     {
  //       menu_type: '1',
  //       parent_id: '0',
  //       icon_native: 'icon-menu-intruduce.png',
  //       menu_name: '项目介绍',
  //       sort: '107',
  //       type: 1,
  //       url: '/layoutView/introduceProjectView',
  //       children: [],
  //     },
  //     {
  //       menu_type: '2',
  //       parent_id: '0',
  //       icon_native: 'icon-menu-produce.png',
  //       menu_name: '产品中心',
  //       sort: '109',
  //       type: 2,
  //       page: '',
  //       children: [
  //         {
  //           menu_type: '2-1',
  //           parent_id: '2',
  //           icon_native: 'icon-home.png',
  //           menu_name: '产品分类',
  //           sort: '110',
  //           type: 1,
  //           url: '/product-center/product-category',
  //           children: [],
  //         },
  //         {
  //           menu_type: '2-2',
  //           parent_id: '2',
  //           icon_native: 'icon-home.png',
  //           menu_name: '产品信息',
  //           sort: '111',
  //           type: 1,
  //           url: '/product-center/product-information',
  //           children: [],
  //         },
  //       ],
  //     },
  //     {
  //       menu_type: '3',
  //       parent_id: '0',
  //       icon_native: 'icon-menu-manage.png',
  //       menu_name: '系统管理',
  //       sort: '112',
  //       type: 2,
  //       page: '',
  //       children: [
  //         {
  //           menu_type: '3-1',
  //           parent_id: '3',
  //           icon_native: 'icon-home.png',
  //           menu_name: '部门管理',
  //           sort: '113',
  //           type: 1,
  //           url: '/sys-management/department-management',
  //           children: [],
  //         },
  //         {
  //           menu_type: '3-2',
  //           parent_id: '3',
  //           icon_native: 'icon-home.png',
  //           menu_name: '菜单管理',
  //           sort: '114',
  //           type: 1,
  //           url: '/sys-management/menu-management',
  //           children: [],
  //         },
  //         {
  //           menu_type: '3-3',
  //           parent_id: '3',
  //           icon_native: 'icon-home.png',
  //           menu_name: '角色管理',
  //           sort: '115',
  //           type: 1,
  //           url: '/sys-management/role-management',
  //           children: [],
  //         },
  //         {
  //           menu_type: '3-4',
  //           parent_id: '3',
  //           icon_native: 'icon-home.png',
  //           menu_name: '用户管理',
  //           sort: '116',
  //           type: 1,
  //           url: '/sys-management/user-management',
  //           children: [],
  //         },
  //       ],
  //     },
  //     {
  //       menu_type: '4',
  //       parent_id: '0',
  //       icon_native: 'icon-menu-overview.png',
  //       menu_name: '系统总览',
  //       sort: '120',
  //       type: 2,
  //       page: '',
  //       children: [
  //         {
  //           menu_type: '4-1',
  //           parent_id: '4',
  //           icon_native: 'icon-home.png',
  //           menu_name: '商品统计',
  //           sort: '121',
  //           type: 1,
  //           url: '/sys-overview/product-statistics-view',
  //           children: [],
  //         },
  //         {
  //           menu_type: '4-2',
  //           parent_id: '4',
  //           icon_native: 'icon-home.png',
  //           menu_name: '核心技术',
  //           sort: '122',
  //           type: 1,
  //           url: '/sys-overview/technology-view',
  //           children: [],
  //         },
  //       ],
  //     },
  //     {
  //       menu_type: '5',
  //       parent_id: '0',
  //       icon_native: 'icon-menu-stroke.png',
  //       menu_name: '日常流程',
  //       sort: '130',
  //       type: 2,
  //       page: '',
  //       children: [
  //         {
  //           menu_type: '5-1',
  //           parent_id: '5',
  //           icon_native: 'icon-home.png',
  //           menu_name: '任务列表',
  //           sort: '131',
  //           type: 1,
  //           url: '/other/task-list',
  //           children: [],
  //         },
  //         {
  //           menu_type: '5-2',
  //           parent_id: '5',
  //           icon_native: 'icon-home.png',
  //           menu_name: '我的日记',
  //           sort: '132',
  //           type: 2,
  //           url: '/other/my-diary',
  //           children: [
  //             {
  //               menu_type: '5-2-1',
  //               parent_id: '5-2',
  //               icon_native: 'icon-home.png',
  //               menu_name: '日记列表',
  //               sort: '133',
  //               type: 1,
  //               url: '/other/my-diary/diary-list',
  //               children: [],
  //             },
  //             {
  //               menu_type: '5-2-2',
  //               parent_id: '5-2',
  //               icon_native: 'icon-home.png',
  //               menu_name: '新增日记',
  //               sort: '134',
  //               type: 1,
  //               url: '/other/my-diary/diary-add',
  //               children: [],
  //             },
  //           ],
  //         },
  //       ],
  //     },
  //   ],
  // }
  // setTimeout(() => {
  //   res.send({
  //     'code': 0,
  //     'msg': '查询成功',
  //     'data': data,
  //   })
  // }, 100);

  // return

  // const user_id = req.query.user_id
};

module.exports = {
  get_verifycode,
  post_register,
  post_login_account,
  post_login_phone,
  get_userinfo,
  get_menulist,
  p_register,
};
